home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Freeware / Miro 1.0 / Miro_Installer.exe / Miro_Downloader.exe / platform.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-11-12  |  28.8 KB  |  1,082 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. ''' This module tries to retrieve as much platform-identifying data as
  5.     possible. It makes this information available via function APIs.
  6.  
  7.     If called from the command line, it prints the platform
  8.     information concatenated as single string to stdout. The output
  9.     format is useable as part of a filename.
  10.  
  11. '''
  12. __copyright__ = '\n    Copyright (c) 1999-2000, Marc-Andre Lemburg; mailto:mal@lemburg.com\n    Copyright (c) 2000-2003, eGenix.com Software GmbH; mailto:info@egenix.com\n\n    Permission to use, copy, modify, and distribute this software and its\n    documentation for any purpose and without fee or royalty is hereby granted,\n    provided that the above copyright notice appear in all copies and that\n    both that copyright notice and this permission notice appear in\n    supporting documentation or portions thereof, including modifications,\n    that you make.\n\n    EGENIX.COM SOFTWARE GMBH DISCLAIMS ALL WARRANTIES WITH REGARD TO\n    THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\n    FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,\n    INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING\n    FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,\n    NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION\n    WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !\n\n'
  13. __version__ = '1.0.4'
  14. import sys
  15. import string
  16. import os
  17. import re
  18. _libc_search = re.compile('(__libc_init)|(GLIBC_([0-9.]+))|(libc(_\\w+)?\\.so(?:\\.(\\d[0-9.]*))?)')
  19.  
  20. def libc_ver(executable = sys.executable, lib = '', version = '', chunksize = 2048):
  21.     ''' Tries to determine the libc version that the file executable
  22.         (which defaults to the Python interpreter) is linked against.
  23.  
  24.         Returns a tuple of strings (lib,version) which default to the
  25.         given parameters in case the lookup fails.
  26.  
  27.         Note that the function has intimate knowledge of how different
  28.         libc versions add symbols to the executable and thus is probably
  29.         only useable for executables compiled using gcc.
  30.  
  31.         The file is read and scanned in chunks of chunksize bytes.
  32.  
  33.     '''
  34.     f = open(executable, 'rb')
  35.     binary = f.read(chunksize)
  36.     pos = 0
  37.     while None:
  38.         m = _libc_search.search(binary, pos)
  39.         if not m:
  40.             binary = f.read(chunksize)
  41.             if not binary:
  42.                 break
  43.             
  44.             pos = 0
  45.             continue
  46.         
  47.         (libcinit, glibc, glibcversion, so, threads, soversion) = m.groups()
  48.         if libcinit and not lib:
  49.             lib = 'libc'
  50.         elif glibc:
  51.             if lib != 'glibc':
  52.                 lib = 'glibc'
  53.                 version = glibcversion
  54.             elif glibcversion > version:
  55.                 version = glibcversion
  56.             
  57.         elif so:
  58.             if lib != 'glibc':
  59.                 lib = 'libc'
  60.                 if soversion > version:
  61.                     version = soversion
  62.                 
  63.                 if threads and version[-len(threads):] != threads:
  64.                     version = version + threads
  65.                 
  66.             
  67.         
  68.         pos = m.end()
  69.         continue
  70.         return (lib, version)
  71.  
  72.  
  73. def _dist_try_harder(distname, version, id):
  74.     ''' Tries some special tricks to get the distribution
  75.         information in case the default method fails.
  76.  
  77.         Currently supports older SuSE Linux, Caldera OpenLinux and
  78.         Slackware Linux distributions.
  79.  
  80.     '''
  81.     if os.path.exists('/var/adm/inst-log/info'):
  82.         info = open('/var/adm/inst-log/info').readlines()
  83.         distname = 'SuSE'
  84.         for line in info:
  85.             tv = string.split(line)
  86.             if len(tv) == 2:
  87.                 (tag, value) = tv
  88.             
  89.             if tag == 'MIN_DIST_VERSION':
  90.                 version = string.strip(value)
  91.                 continue
  92.             len(tv) == 2
  93.             if tag == 'DIST_IDENT':
  94.                 values = string.split(value, '-')
  95.                 id = values[2]
  96.                 continue
  97.         
  98.         return (distname, version, id)
  99.     
  100.     if os.path.exists('/etc/.installed'):
  101.         info = open('/etc/.installed').readlines()
  102.         for line in info:
  103.             pkg = string.split(line, '-')
  104.             if len(pkg) >= 2 and pkg[0] == 'OpenLinux':
  105.                 return ('OpenLinux', pkg[1], id)
  106.                 continue
  107.         
  108.     
  109.     if os.path.isdir('/usr/lib/setup'):
  110.         verfiles = os.listdir('/usr/lib/setup')
  111.         for n in range(len(verfiles) - 1, -1, -1):
  112.             if verfiles[n][:14] != 'slack-version-':
  113.                 del verfiles[n]
  114.                 continue
  115.         
  116.         if verfiles:
  117.             verfiles.sort()
  118.             distname = 'slackware'
  119.             version = verfiles[-1][14:]
  120.             return (distname, version, id)
  121.         
  122.     
  123.     return (distname, version, id)
  124.  
  125. _release_filename = re.compile('(\\w+)[-_](release|version)')
  126. _release_version = re.compile('([\\d.]+)[^(]*(?:\\((.+)\\))?')
  127.  
  128. def dist(distname = '', version = '', id = '', supported_dists = ('SuSE', 'debian', 'fedora', 'redhat', 'mandrake')):
  129.     ''' Tries to determine the name of the Linux OS distribution name.
  130.  
  131.         The function first looks for a distribution release file in
  132.         /etc and then reverts to _dist_try_harder() in case no
  133.         suitable files are found.
  134.  
  135.         Returns a tuple (distname,version,id) which default to the
  136.         args given as parameters.
  137.  
  138.     '''
  139.     
  140.     try:
  141.         etc = os.listdir('/etc')
  142.     except os.error:
  143.         return (distname, version, id)
  144.  
  145.     for file in etc:
  146.         m = _release_filename.match(file)
  147.         if m:
  148.             (_distname, dummy) = m.groups()
  149.             if _distname in supported_dists:
  150.                 distname = _distname
  151.                 break
  152.             
  153.         _distname in supported_dists
  154.     else:
  155.         return _dist_try_harder(distname, version, id)
  156.     f = open('/etc/' + file, 'r')
  157.     firstline = f.readline()
  158.     f.close()
  159.     m = _release_version.search(firstline)
  160.     if m:
  161.         (_version, _id) = m.groups()
  162.         if _version:
  163.             version = _version
  164.         
  165.         if _id:
  166.             id = _id
  167.         
  168.     else:
  169.         l = string.split(string.strip(firstline))
  170.         if l:
  171.             version = l[0]
  172.             if len(l) > 1:
  173.                 id = l[1]
  174.             
  175.         
  176.     return (distname, version, id)
  177.  
  178.  
  179. class _popen:
  180.     """ Fairly portable (alternative) popen implementation.
  181.  
  182.         This is mostly needed in case os.popen() is not available, or
  183.         doesn't work as advertised, e.g. in Win9X GUI programs like
  184.         PythonWin or IDLE.
  185.  
  186.         Writing to the pipe is currently not supported.
  187.  
  188.     """
  189.     tmpfile = ''
  190.     pipe = None
  191.     bufsize = None
  192.     mode = 'r'
  193.     
  194.     def __init__(self, cmd, mode = 'r', bufsize = None):
  195.         if mode != 'r':
  196.             raise ValueError, 'popen()-emulation only supports read mode'
  197.         
  198.         import tempfile
  199.         self.tmpfile = tmpfile = tempfile.mktemp()
  200.         os.system(cmd + ' > %s' % tmpfile)
  201.         self.pipe = open(tmpfile, 'rb')
  202.         self.bufsize = bufsize
  203.         self.mode = mode
  204.  
  205.     
  206.     def read(self):
  207.         return self.pipe.read()
  208.  
  209.     
  210.     def readlines(self):
  211.         if self.bufsize is not None:
  212.             return self.pipe.readlines()
  213.         
  214.  
  215.     
  216.     def close(self, remove = os.unlink, error = os.error):
  217.         if self.pipe:
  218.             rc = self.pipe.close()
  219.         else:
  220.             rc = 255
  221.         if self.tmpfile:
  222.             
  223.             try:
  224.                 remove(self.tmpfile)
  225.             except error:
  226.                 pass
  227.             except:
  228.                 None<EXCEPTION MATCH>error
  229.             
  230.  
  231.         None<EXCEPTION MATCH>error
  232.         return rc
  233.  
  234.     __del__ = close
  235.  
  236.  
  237. def popen(cmd, mode = 'r', bufsize = None):
  238.     ''' Portable popen() interface.
  239.     '''
  240.     popen = None
  241.     if os.environ.get('OS', '') == 'Windows_NT':
  242.         
  243.         try:
  244.             import win32pipe
  245.         except ImportError:
  246.             pass
  247.  
  248.         popen = win32pipe.popen
  249.     
  250.     if popen is None:
  251.         if hasattr(os, 'popen'):
  252.             popen = os.popen
  253.             if sys.platform == 'win32':
  254.                 
  255.                 try:
  256.                     popen('')
  257.                 except os.error:
  258.                     popen = _popen
  259.                 except:
  260.                     None<EXCEPTION MATCH>os.error
  261.                 
  262.  
  263.             None<EXCEPTION MATCH>os.error
  264.         else:
  265.             popen = _popen
  266.     
  267.     if bufsize is None:
  268.         return popen(cmd, mode)
  269.     else:
  270.         return popen(cmd, mode, bufsize)
  271.  
  272.  
  273. def _norm_version(version, build = ''):
  274.     ''' Normalize the version and build strings and return a single
  275.         version string using the format major.minor.build (or patchlevel).
  276.     '''
  277.     l = string.split(version, '.')
  278.     if build:
  279.         l.append(build)
  280.     
  281.     
  282.     try:
  283.         ints = map(int, l)
  284.     except ValueError:
  285.         strings = l
  286.  
  287.     strings = map(str, ints)
  288.     version = string.join(strings[:3], '.')
  289.     return version
  290.  
  291. _ver_output = re.compile('(?:([\\w ]+) ([\\w.]+) .*Version ([\\d.]+))')
  292.  
  293. def _syscmd_ver(system = '', release = '', version = '', supported_platforms = ('win32', 'win16', 'dos', 'os2')):
  294.     ''' Tries to figure out the OS version used and returns
  295.         a tuple (system,release,version).
  296.  
  297.         It uses the "ver" shell command for this which is known
  298.         to exists on Windows, DOS and OS/2. XXX Others too ?
  299.  
  300.         In case this fails, the given parameters are used as
  301.         defaults.
  302.  
  303.     '''
  304.     if sys.platform not in supported_platforms:
  305.         return (system, release, version)
  306.     
  307.     for cmd in ('ver', 'command /c ver', 'cmd /c ver'):
  308.         
  309.         try:
  310.             pipe = popen(cmd)
  311.             info = pipe.read()
  312.             if pipe.close():
  313.                 raise os.error, 'command failed'
  314.         except os.error:
  315.             why = None
  316.             continue
  317.             continue
  318.             except IOError:
  319.                 why = None
  320.                 continue
  321.                 continue
  322.             else:
  323.                 break
  324.         return (system, release, version)
  325.         info = string.strip(info)
  326.         m = _ver_output.match(info)
  327.         if m:
  328.             (system, release, version) = m.groups()
  329.             if release[-1] == '.':
  330.                 release = release[:-1]
  331.             
  332.             if version[-1] == '.':
  333.                 version = version[:-1]
  334.             
  335.             version = _norm_version(version)
  336.         
  337.  
  338.     return (system, release, version)
  339.  
  340.  
  341. def _win32_getvalue(key, name, default = ''):
  342.     ''' Read a value for name from the registry key.
  343.  
  344.         In case this fails, default is returned.
  345.  
  346.     '''
  347.     RegQueryValueEx = RegQueryValueEx
  348.     import win32api
  349.     
  350.     try:
  351.         return RegQueryValueEx(key, name)
  352.     except:
  353.         return default
  354.  
  355.  
  356.  
  357. def win32_ver(release = '', version = '', csd = '', ptype = ''):
  358.     """ Get additional version information from the Windows Registry
  359.         and return a tuple (version,csd,ptype) referring to version
  360.         number, CSD level and OS type (multi/single
  361.         processor).
  362.  
  363.         As a hint: ptype returns 'Uniprocessor Free' on single
  364.         processor NT machines and 'Multiprocessor Free' on multi
  365.         processor machines. The 'Free' refers to the OS version being
  366.         free of debugging code. It could also state 'Checked' which
  367.         means the OS version uses debugging code, i.e. code that
  368.         checks arguments, ranges, etc. (Thomas Heller).
  369.  
  370.         Note: this function only works if Mark Hammond's win32
  371.         package is installed and obviously only runs on Win32
  372.         compatible platforms.
  373.  
  374.     """
  375.     
  376.     try:
  377.         import win32api
  378.     except ImportError:
  379.         return (release, version, csd, ptype)
  380.  
  381.     RegQueryValueEx = RegQueryValueEx
  382.     RegOpenKeyEx = RegOpenKeyEx
  383.     RegCloseKey = RegCloseKey
  384.     GetVersionEx = GetVersionEx
  385.     import win32api
  386.     HKEY_LOCAL_MACHINE = HKEY_LOCAL_MACHINE
  387.     VER_PLATFORM_WIN32_NT = VER_PLATFORM_WIN32_NT
  388.     VER_PLATFORM_WIN32_WINDOWS = VER_PLATFORM_WIN32_WINDOWS
  389.     import win32con
  390.     (maj, min, buildno, plat, csd) = GetVersionEx()
  391.     version = '%i.%i.%i' % (maj, min, buildno & 65535)
  392.     if csd[:13] == 'Service Pack ':
  393.         csd = 'SP' + csd[13:]
  394.     
  395.     if plat == VER_PLATFORM_WIN32_WINDOWS:
  396.         regkey = 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion'
  397.         if maj == 4:
  398.             if min == 0:
  399.                 release = '95'
  400.             elif min == 10:
  401.                 release = '98'
  402.             elif min == 90:
  403.                 release = 'Me'
  404.             else:
  405.                 release = 'postMe'
  406.         elif maj == 5:
  407.             release = '2000'
  408.         
  409.     elif plat == VER_PLATFORM_WIN32_NT:
  410.         regkey = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion'
  411.         if maj <= 4:
  412.             release = 'NT'
  413.         elif maj == 5:
  414.             if min == 0:
  415.                 release = '2000'
  416.             elif min == 1:
  417.                 release = 'XP'
  418.             elif min == 2:
  419.                 release = '2003Server'
  420.             else:
  421.                 release = 'post2003'
  422.         
  423.     elif not release:
  424.         release = '%i.%i' % (maj, min)
  425.     
  426.     return (release, version, csd, ptype)
  427.     
  428.     try:
  429.         keyCurVer = RegOpenKeyEx(HKEY_LOCAL_MACHINE, regkey)
  430.         RegQueryValueEx(keyCurVer, 'SystemRoot')
  431.     except:
  432.         return (release, version, csd, ptype)
  433.  
  434.     build = _win32_getvalue(keyCurVer, 'CurrentBuildNumber', ('', 1))[0]
  435.     ptype = _win32_getvalue(keyCurVer, 'CurrentType', (ptype, 1))[0]
  436.     version = _norm_version(version, build)
  437.     RegCloseKey(keyCurVer)
  438.     return (release, version, csd, ptype)
  439.  
  440.  
  441. def _mac_ver_lookup(selectors, default = None):
  442.     gestalt = gestalt
  443.     import gestalt
  444.     import MacOS
  445.     l = []
  446.     append = l.append
  447.     for selector in selectors:
  448.         
  449.         try:
  450.             append(gestalt(selector))
  451.         continue
  452.         except (RuntimeError, MacOS.Error):
  453.             append(default)
  454.             continue
  455.         
  456.  
  457.     
  458.     return l
  459.  
  460.  
  461. def _bcd2str(bcd):
  462.     return hex(bcd)[2:]
  463.  
  464.  
  465. def mac_ver(release = '', versioninfo = ('', '', ''), machine = ''):
  466.     """ Get MacOS version information and return it as tuple (release,
  467.         versioninfo, machine) with versioninfo being a tuple (version,
  468.         dev_stage, non_release_version).
  469.  
  470.         Entries which cannot be determined are set to the paramter values
  471.         which default to ''. All tuple entries are strings.
  472.  
  473.         Thanks to Mark R. Levinson for mailing documentation links and
  474.         code examples for this function. Documentation for the
  475.         gestalt() API is available online at:
  476.  
  477.            http://www.rgaros.nl/gestalt/
  478.  
  479.     """
  480.     
  481.     try:
  482.         import gestalt
  483.         import MacOS
  484.     except ImportError:
  485.         return (release, versioninfo, machine)
  486.  
  487.     (sysv, sysu, sysa) = _mac_ver_lookup(('sysv', 'sysu', 'sysa'))
  488.     if sysv:
  489.         major = (sysv & 65280) >> 8
  490.         minor = (sysv & 240) >> 4
  491.         patch = sysv & 15
  492.         release = '%s.%i.%i' % (_bcd2str(major), minor, patch)
  493.     
  494.     if sysu:
  495.         major = int((sysu & 0xFF000000L) >> 24)
  496.         minor = (sysu & 15728640) >> 20
  497.         bugfix = (sysu & 983040) >> 16
  498.         stage = (sysu & 65280) >> 8
  499.         nonrel = sysu & 255
  500.         version = '%s.%i.%i' % (_bcd2str(major), minor, bugfix)
  501.         nonrel = _bcd2str(nonrel)
  502.         stage = {
  503.             32: 'development',
  504.             64: 'alpha',
  505.             96: 'beta',
  506.             128: 'final' }.get(stage, '')
  507.         versioninfo = (version, stage, nonrel)
  508.     
  509.     if sysa:
  510.         machine = {
  511.             1: '68k',
  512.             2: 'PowerPC',
  513.             10: 'i386' }.get(sysa, '')
  514.     
  515.     return (release, versioninfo, machine)
  516.  
  517.  
  518. def _java_getprop(name, default):
  519.     System = System
  520.     import java.lang
  521.     
  522.     try:
  523.         return System.getProperty(name)
  524.     except:
  525.         return default
  526.  
  527.  
  528.  
  529. def java_ver(release = '', vendor = '', vminfo = ('', '', ''), osinfo = ('', '', '')):
  530.     """ Version interface for Jython.
  531.  
  532.         Returns a tuple (release,vendor,vminfo,osinfo) with vminfo being
  533.         a tuple (vm_name,vm_release,vm_vendor) and osinfo being a
  534.         tuple (os_name,os_version,os_arch).
  535.  
  536.         Values which cannot be determined are set to the defaults
  537.         given as parameters (which all default to '').
  538.  
  539.     """
  540.     
  541.     try:
  542.         import java.lang as java
  543.     except ImportError:
  544.         return (release, vendor, vminfo, osinfo)
  545.  
  546.     vendor = _java_getprop('java.vendor', vendor)
  547.     release = _java_getprop('java.version', release)
  548.     (vm_name, vm_release, vm_vendor) = vminfo
  549.     vm_name = _java_getprop('java.vm.name', vm_name)
  550.     vm_vendor = _java_getprop('java.vm.vendor', vm_vendor)
  551.     vm_release = _java_getprop('java.vm.version', vm_release)
  552.     vminfo = (vm_name, vm_release, vm_vendor)
  553.     (os_name, os_version, os_arch) = osinfo
  554.     os_arch = _java_getprop('java.os.arch', os_arch)
  555.     os_name = _java_getprop('java.os.name', os_name)
  556.     os_version = _java_getprop('java.os.version', os_version)
  557.     osinfo = (os_name, os_version, os_arch)
  558.     return (release, vendor, vminfo, osinfo)
  559.  
  560.  
  561. def system_alias(system, release, version):
  562.     ''' Returns (system,release,version) aliased to common
  563.         marketing names used for some systems.
  564.  
  565.         It also does some reordering of the information in some cases
  566.         where it would otherwise cause confusion.
  567.  
  568.     '''
  569.     if system == 'Rhapsody':
  570.         return ('MacOS X Server', system + release, version)
  571.     elif system == 'SunOS':
  572.         if release < '5':
  573.             return (system, release, version)
  574.         
  575.         l = string.split(release, '.')
  576.         if l:
  577.             
  578.             try:
  579.                 major = int(l[0])
  580.             except ValueError:
  581.                 pass
  582.  
  583.             major = major - 3
  584.             l[0] = str(major)
  585.             release = string.join(l, '.')
  586.         
  587.         if release < '6':
  588.             system = 'Solaris'
  589.         else:
  590.             system = 'Solaris'
  591.     elif system == 'IRIX64':
  592.         system = 'IRIX'
  593.         if version:
  594.             version = version + ' (64bit)'
  595.         else:
  596.             version = '64bit'
  597.     elif system in ('win32', 'win16'):
  598.         system = 'Windows'
  599.     
  600.     return (system, release, version)
  601.  
  602.  
  603. def _platform(*args):
  604.     ''' Helper to format the platform string in a filename
  605.         compatible format e.g. "system-version-machine".
  606.     '''
  607.     platform = string.join(map(string.strip, filter(len, args)), '-')
  608.     replace = string.replace
  609.     platform = replace(platform, ' ', '_')
  610.     platform = replace(platform, '/', '-')
  611.     platform = replace(platform, '\\', '-')
  612.     platform = replace(platform, ':', '-')
  613.     platform = replace(platform, ';', '-')
  614.     platform = replace(platform, '"', '-')
  615.     platform = replace(platform, '(', '-')
  616.     platform = replace(platform, ')', '-')
  617.     platform = replace(platform, 'unknown', '')
  618.     while None:
  619.         cleaned = replace(platform, '--', '-')
  620.         if cleaned == platform:
  621.             break
  622.         
  623.         platform = cleaned
  624.         continue
  625.         while platform[-1] == '-':
  626.             platform = platform[:-1]
  627.         return platform
  628.  
  629.  
  630. def _node(default = ''):
  631.     ''' Helper to determine the node name of this machine.
  632.     '''
  633.     
  634.     try:
  635.         import socket
  636.     except ImportError:
  637.         return default
  638.  
  639.     
  640.     try:
  641.         return socket.gethostname()
  642.     except socket.error:
  643.         return default
  644.  
  645.  
  646. if not hasattr(os.path, 'abspath'):
  647.     
  648.     def _abspath(path, isabs = os.path.isabs, join = os.path.join, getcwd = os.getcwd, normpath = os.path.normpath):
  649.         if not isabs(path):
  650.             path = join(getcwd(), path)
  651.         
  652.         return normpath(path)
  653.  
  654. else:
  655.     _abspath = os.path.abspath
  656.  
  657. def _follow_symlinks(filepath):
  658.     ''' In case filepath is a symlink, follow it until a
  659.         real file is reached.
  660.     '''
  661.     filepath = _abspath(filepath)
  662.     while os.path.islink(filepath):
  663.         filepath = os.path.normpath(os.path.join(filepath, os.readlink(filepath)))
  664.     return filepath
  665.  
  666.  
  667. def _syscmd_uname(option, default = ''):
  668.     """ Interface to the system's uname command.
  669.     """
  670.     if sys.platform in ('dos', 'win32', 'win16', 'os2'):
  671.         return default
  672.     
  673.     
  674.     try:
  675.         f = os.popen('uname %s 2> /dev/null' % option)
  676.     except (AttributeError, os.error):
  677.         return default
  678.  
  679.     output = string.strip(f.read())
  680.     rc = f.close()
  681.     if not output or rc:
  682.         return default
  683.     else:
  684.         return output
  685.  
  686.  
  687. def _syscmd_file(target, default = ''):
  688.     """ Interface to the system's file command.
  689.  
  690.         The function uses the -b option of the file command to have it
  691.         ommit the filename in its output and if possible the -L option
  692.         to have the command follow symlinks. It returns default in
  693.         case the command should fail.
  694.  
  695.     """
  696.     target = _follow_symlinks(target)
  697.     
  698.     try:
  699.         f = os.popen('file %s 2> /dev/null' % target)
  700.     except (AttributeError, os.error):
  701.         return default
  702.  
  703.     output = string.strip(f.read())
  704.     rc = f.close()
  705.     if not output or rc:
  706.         return default
  707.     else:
  708.         return output
  709.  
  710. _default_architecture = {
  711.     'win32': ('', 'WindowsPE'),
  712.     'win16': ('', 'Windows'),
  713.     'dos': ('', 'MSDOS') }
  714. _architecture_split = re.compile('[\\s,]').split
  715.  
  716. def architecture(executable = sys.executable, bits = '', linkage = ''):
  717.     ''' Queries the given executable (defaults to the Python interpreter
  718.         binary) for various architecture information.
  719.  
  720.         Returns a tuple (bits,linkage) which contains information about
  721.         the bit architecture and the linkage format used for the
  722.         executable. Both values are returned as strings.
  723.  
  724.         Values that cannot be determined are returned as given by the
  725.         parameter presets. If bits is given as \'\', the sizeof(pointer)
  726.         (or sizeof(long) on Python version < 1.5.2) is used as
  727.         indicator for the supported pointer size.
  728.  
  729.         The function relies on the system\'s "file" command to do the
  730.         actual work. This is available on most if not all Unix
  731.         platforms. On some non-Unix platforms where the "file" command
  732.         does not exist and the executable is set to the Python interpreter
  733.         binary defaults from _default_architecture are used.
  734.  
  735.     '''
  736.     if not bits:
  737.         import struct
  738.         
  739.         try:
  740.             size = struct.calcsize('P')
  741.         except struct.error:
  742.             size = struct.calcsize('l')
  743.  
  744.         bits = str(size * 8) + 'bit'
  745.     
  746.     output = _syscmd_file(executable, '')
  747.     if not output and executable == sys.executable:
  748.         if _default_architecture.has_key(sys.platform):
  749.             (b, l) = _default_architecture[sys.platform]
  750.             if b:
  751.                 bits = b
  752.             
  753.             if l:
  754.                 linkage = l
  755.             
  756.         
  757.         return (bits, linkage)
  758.     
  759.     fileout = _architecture_split(output)[1:]
  760.     if 'executable' not in fileout:
  761.         return (bits, linkage)
  762.     
  763.     if '32-bit' in fileout:
  764.         bits = '32bit'
  765.     elif 'N32' in fileout:
  766.         bits = 'n32bit'
  767.     elif '64-bit' in fileout:
  768.         bits = '64bit'
  769.     
  770.     if 'ELF' in fileout:
  771.         linkage = 'ELF'
  772.     elif 'PE' in fileout:
  773.         if 'Windows' in fileout:
  774.             linkage = 'WindowsPE'
  775.         else:
  776.             linkage = 'PE'
  777.     elif 'COFF' in fileout:
  778.         linkage = 'COFF'
  779.     elif 'MS-DOS' in fileout:
  780.         linkage = 'MSDOS'
  781.     
  782.     return (bits, linkage)
  783.  
  784. _uname_cache = None
  785.  
  786. def uname():
  787.     """ Fairly portable uname interface. Returns a tuple
  788.         of strings (system,node,release,version,machine,processor)
  789.         identifying the underlying platform.
  790.  
  791.         Note that unlike the os.uname function this also returns
  792.         possible processor information as an additional tuple entry.
  793.  
  794.         Entries which cannot be determined are set to ''.
  795.  
  796.     """
  797.     global _uname_cache
  798.     if _uname_cache is not None:
  799.         return _uname_cache
  800.     
  801.     
  802.     try:
  803.         (system, node, release, version, machine) = os.uname()
  804.     except AttributeError:
  805.         system = sys.platform
  806.         release = ''
  807.         version = ''
  808.         node = _node()
  809.         machine = ''
  810.         processor = ''
  811.         use_syscmd_ver = 1
  812.         if system == 'win32':
  813.             (release, version, csd, ptype) = win32_ver()
  814.             if release and version:
  815.                 use_syscmd_ver = 0
  816.             
  817.         
  818.         if use_syscmd_ver:
  819.             (system, release, version) = _syscmd_ver(system)
  820.             if system == 'Microsoft Windows':
  821.                 system = 'Windows'
  822.             
  823.         
  824.         if system in ('win32', 'win16'):
  825.             if not version:
  826.                 if system == 'win32':
  827.                     version = '32bit'
  828.                 else:
  829.                     version = '16bit'
  830.             
  831.             system = 'Windows'
  832.         elif system[:4] == 'java':
  833.             (release, vendor, vminfo, osinfo) = java_ver()
  834.             system = 'Java'
  835.             version = string.join(vminfo, ', ')
  836.             if not version:
  837.                 version = vendor
  838.             
  839.         elif os.name == 'mac':
  840.             (version, stage, nonrel) = (release,)
  841.             machine = mac_ver()
  842.             system = 'MacOS'
  843.         
  844.     except:
  845.         system in ('win32', 'win16')
  846.  
  847.     if system == 'OpenVMS':
  848.         if not release or release == '0':
  849.             release = version
  850.             version = ''
  851.         
  852.         
  853.         try:
  854.             import vms_lib
  855.         except ImportError:
  856.             pass
  857.  
  858.         (csid, cpu_number) = vms_lib.getsyi('SYI$_CPU', 0)
  859.         if cpu_number >= 128:
  860.             processor = 'Alpha'
  861.         else:
  862.             processor = 'VAX'
  863.     else:
  864.         processor = _syscmd_uname('-p', '')
  865.     if system == 'unknown':
  866.         system = ''
  867.     
  868.     if node == 'unknown':
  869.         node = ''
  870.     
  871.     if release == 'unknown':
  872.         release = ''
  873.     
  874.     if version == 'unknown':
  875.         version = ''
  876.     
  877.     if machine == 'unknown':
  878.         machine = ''
  879.     
  880.     if processor == 'unknown':
  881.         processor = ''
  882.     
  883.     _uname_cache = (system, node, release, version, machine, processor)
  884.     return _uname_cache
  885.  
  886.  
  887. def system():
  888.     """ Returns the system/OS name, e.g. 'Linux', 'Windows' or 'Java'.
  889.  
  890.         An empty string is returned if the value cannot be determined.
  891.  
  892.     """
  893.     return uname()[0]
  894.  
  895.  
  896. def node():
  897.     """ Returns the computer's network name (which may not be fully
  898.         qualified)
  899.  
  900.         An empty string is returned if the value cannot be determined.
  901.  
  902.     """
  903.     return uname()[1]
  904.  
  905.  
  906. def release():
  907.     """ Returns the system's release, e.g. '2.2.0' or 'NT'
  908.  
  909.         An empty string is returned if the value cannot be determined.
  910.  
  911.     """
  912.     return uname()[2]
  913.  
  914.  
  915. def version():
  916.     """ Returns the system's release version, e.g. '#3 on degas'
  917.  
  918.         An empty string is returned if the value cannot be determined.
  919.  
  920.     """
  921.     return uname()[3]
  922.  
  923.  
  924. def machine():
  925.     """ Returns the machine type, e.g. 'i386'
  926.  
  927.         An empty string is returned if the value cannot be determined.
  928.  
  929.     """
  930.     return uname()[4]
  931.  
  932.  
  933. def processor():
  934.     """ Returns the (true) processor name, e.g. 'amdk6'
  935.  
  936.         An empty string is returned if the value cannot be
  937.         determined. Note that many platforms do not provide this
  938.         information or simply return the same value as for machine(),
  939.         e.g.  NetBSD does this.
  940.  
  941.     """
  942.     return uname()[5]
  943.  
  944. _sys_version_parser = re.compile('([\\w.+]+)\\s*\\(#?([^,]+),\\s*([\\w ]+),\\s*([\\w :]+)\\)\\s*\\[([^\\]]+)\\]?')
  945. _sys_version_cache = None
  946.  
  947. def _sys_version():
  948.     """ Returns a parsed version of Python's sys.version as tuple
  949.         (version, buildno, builddate, compiler) referring to the Python
  950.         version, build number, build date/time as string and the compiler
  951.         identification string.
  952.  
  953.         Note that unlike the Python sys.version, the returned value
  954.         for the Python version will always include the patchlevel (it
  955.         defaults to '.0').
  956.  
  957.     """
  958.     global _sys_version_cache
  959.     if _sys_version_cache is not None:
  960.         return _sys_version_cache
  961.     
  962.     (version, buildno, builddate, buildtime, compiler) = _sys_version_parser.match(sys.version).groups()
  963.     builddate = builddate + ' ' + buildtime
  964.     l = string.split(version, '.')
  965.     if len(l) == 2:
  966.         l.append('0')
  967.         version = string.join(l, '.')
  968.     
  969.     _sys_version_cache = (version, buildno, builddate, compiler)
  970.     return _sys_version_cache
  971.  
  972.  
  973. def python_version():
  974.     """ Returns the Python version as string 'major.minor.patchlevel'
  975.  
  976.         Note that unlike the Python sys.version, the returned value
  977.         will always include the patchlevel (it defaults to 0).
  978.  
  979.     """
  980.     return _sys_version()[0]
  981.  
  982.  
  983. def python_version_tuple():
  984.     ''' Returns the Python version as tuple (major, minor, patchlevel)
  985.         of strings.
  986.  
  987.         Note that unlike the Python sys.version, the returned value
  988.         will always include the patchlevel (it defaults to 0).
  989.  
  990.     '''
  991.     return string.split(_sys_version()[0], '.')
  992.  
  993.  
  994. def python_build():
  995.     ''' Returns a tuple (buildno, builddate) stating the Python
  996.         build number and date as strings.
  997.  
  998.     '''
  999.     return _sys_version()[1:3]
  1000.  
  1001.  
  1002. def python_compiler():
  1003.     ''' Returns a string identifying the compiler used for compiling
  1004.         Python.
  1005.  
  1006.     '''
  1007.     return _sys_version()[3]
  1008.  
  1009. _platform_cache = { }
  1010.  
  1011. def platform(aliased = 0, terse = 0):
  1012.     ''' Returns a single string identifying the underlying platform
  1013.         with as much useful information as possible (but no more :).
  1014.  
  1015.         The output is intended to be human readable rather than
  1016.         machine parseable. It may look different on different
  1017.         platforms and this is intended.
  1018.  
  1019.         If "aliased" is true, the function will use aliases for
  1020.         various platforms that report system names which differ from
  1021.         their common names, e.g. SunOS will be reported as
  1022.         Solaris. The system_alias() function is used to implement
  1023.         this.
  1024.  
  1025.         Setting terse to true causes the function to return only the
  1026.         absolute minimum information needed to identify the platform.
  1027.  
  1028.     '''
  1029.     result = _platform_cache.get((aliased, terse), None)
  1030.     if result is not None:
  1031.         return result
  1032.     
  1033.     (system, node, release, version, machine, processor) = uname()
  1034.     if machine == processor:
  1035.         processor = ''
  1036.     
  1037.     if aliased:
  1038.         (system, release, version) = system_alias(system, release, version)
  1039.     
  1040.     if system == 'Windows':
  1041.         (rel, vers, csd, ptype) = win32_ver(version)
  1042.         if terse:
  1043.             platform = _platform(system, release)
  1044.         else:
  1045.             platform = _platform(system, release, version, csd)
  1046.     elif system in ('Linux',):
  1047.         (distname, distversion, distid) = dist('')
  1048.         if distname and not terse:
  1049.             platform = _platform(system, release, machine, processor, 'with', distname, distversion, distid)
  1050.         else:
  1051.             (libcname, libcversion) = libc_ver(sys.executable)
  1052.             platform = _platform(system, release, machine, processor, 'with', libcname + libcversion)
  1053.     elif system == 'Java':
  1054.         (os_name, os_version, os_arch) = (r, v, vminfo)
  1055.         if terse:
  1056.             platform = _platform(system, release, version)
  1057.         else:
  1058.             platform = _platform(system, release, version, 'on', os_name, os_version, os_arch)
  1059.     elif system == 'MacOS':
  1060.         if terse:
  1061.             platform = _platform(system, release)
  1062.         else:
  1063.             platform = _platform(system, release, machine)
  1064.     elif terse:
  1065.         platform = _platform(system, release)
  1066.     else:
  1067.         (bits, linkage) = architecture(sys.executable)
  1068.         platform = _platform(system, release, machine, processor, bits, linkage)
  1069.     _platform_cache[(aliased, terse)] = platform
  1070.     return platform
  1071.  
  1072. if __name__ == '__main__':
  1073.     if not 'terse' in sys.argv:
  1074.         pass
  1075.     terse = '--terse' in sys.argv
  1076.     if 'nonaliased' not in sys.argv:
  1077.         pass
  1078.     aliased = '--nonaliased' not in sys.argv
  1079.     print platform(aliased, terse)
  1080.     sys.exit(0)
  1081.  
  1082.